home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / SLAX 6.0.8 / slax-6.0.8.iso / slax / base / 006-devel.lzm / usr / include / arts / bufferqueue.h < prev    next >
Encoding:
C/C++ Source or Header  |  2005-09-10  |  3.1 KB  |  149 lines
  1. /*
  2.  * BC - Status (2002-03-08): ByteBuffer, BufferQueue
  3.  *
  4.  * None of these classes is considered part of the public API. Do NOT use it
  5.  * in your apps. These are part of the implementation of libartsflow's
  6.  * AudioSubSystem, and subject to change/disappearing due to optimization
  7.  * work.
  8.  */
  9.  
  10. #ifndef _BUFFERQUEUE_H
  11. #define _BUFFERQUEUE_H
  12.  
  13. #include "thread.h"
  14.  
  15. #define _DEFAULT_CHUNK_SIZE 4096
  16. #define _MAX_CHUNKS 3
  17.  
  18. namespace Arts
  19. {
  20.  
  21. class ByteBuffer
  22. {
  23.     unsigned char* content;
  24.     int _size;
  25.     int _maxSize;
  26.     int rp;
  27.  
  28. public:
  29.     ByteBuffer() {
  30.         _size = rp = 0;
  31.         _maxSize = _DEFAULT_CHUNK_SIZE;
  32.         content = new unsigned char[_DEFAULT_CHUNK_SIZE];
  33.     }
  34.     ByteBuffer(const void* s, int len) {
  35.         _maxSize = _DEFAULT_CHUNK_SIZE;
  36.         content = new unsigned char[_DEFAULT_CHUNK_SIZE];
  37.         put(s, len);
  38.     }
  39.  
  40.     ~ByteBuffer() { delete [] content; }
  41.  
  42.     void put(const void* s, int len) {
  43.         if ((_size = len) != 0)
  44.             memcpy(content, s, len);
  45.         rp = 0;
  46.     }
  47.  
  48.     void* get()          { return content+rp; }
  49.     void* reset()        { _size = 0; rp = 0; return content; }
  50.     int push(int len)    { _size -= len; rp += len; return _size; }
  51.     void set(int len)    { _size = len; rp = 0; }
  52.     int size() const     { return _size; }
  53.     int maxSize() const  { return _maxSize; }
  54.  
  55.     void setMaxSize(int size) {
  56.         delete [] content;
  57.         content = new unsigned char[size];
  58.         _maxSize = size;
  59.     }
  60. };
  61.  
  62. ///////////////////////////////////////////////////////////////////////////////
  63.  
  64. class BufferQueue
  65. {
  66. private:
  67.     ByteBuffer bufs[_MAX_CHUNKS];
  68.     int rp;
  69.     int wp;
  70.     Arts::Semaphore* sema_produced;
  71.     Arts::Semaphore* sema_consumed;
  72.  
  73.     void semaReinit() {
  74.         delete sema_consumed;
  75.         delete sema_produced;
  76.         sema_consumed = new Arts::Semaphore(0, _MAX_CHUNKS);
  77.         sema_produced = new Arts::Semaphore(0, 0);
  78.     }
  79.  
  80.  
  81. public:
  82.     BufferQueue() {
  83.         rp = wp = 0;
  84.         sema_consumed = new Arts::Semaphore(0, _MAX_CHUNKS);
  85.         sema_produced = new Arts::Semaphore(0, 0);
  86.     }
  87.  
  88.     ~BufferQueue() {
  89.         delete sema_consumed;
  90.         delete sema_produced;
  91.     }
  92.  
  93.     void write(void* data, int len);
  94.     ByteBuffer* waitConsumed();
  95.     void produced();
  96.  
  97.     ByteBuffer* waitProduced();
  98.     void consumed();
  99.  
  100.     bool isEmpty() const       { return sema_produced->getValue() == 0; }
  101.     int bufferedChunks() const { return sema_produced->getValue(); }
  102.     int freeChunks() const     { return sema_consumed->getValue(); }
  103.     int maxChunks() const      { return _MAX_CHUNKS; }
  104.     int chunkSize() const      { return bufs[0].maxSize(); }
  105.     void clear()               { rp = wp = 0; semaReinit(); }
  106.     void setChunkSize(int size){
  107.         for (int i=0; i < maxChunks(); i++)
  108.             bufs[i].setMaxSize(size);
  109.     }
  110. };
  111.  
  112. ///////////////////////////////////////////////////////////////////////////////
  113.  
  114. inline void BufferQueue::write(void* data, int len)
  115. {
  116.     sema_consumed->wait();
  117.     bufs[wp].put(data, len);
  118.     ++wp %= _MAX_CHUNKS;
  119.     sema_produced->post();
  120. }
  121.  
  122. inline ByteBuffer* BufferQueue::waitConsumed()
  123. {
  124.     sema_consumed->wait();
  125.     return &bufs[wp];
  126. }
  127.  
  128. inline void BufferQueue::produced()
  129. {
  130.     ++wp %= _MAX_CHUNKS;
  131.     sema_produced->post();
  132. }
  133.  
  134. inline ByteBuffer* BufferQueue::waitProduced()
  135. {
  136.     sema_produced->wait();
  137.     return &bufs[rp];
  138. }
  139.  
  140. inline void BufferQueue::consumed()
  141. {
  142.     ++rp %=_MAX_CHUNKS;
  143.     sema_consumed->post();
  144. }
  145.  
  146. }
  147.  
  148. #endif
  149.